Advances in Active Libraries and Generic Programming

Interpretation of Predicates In this section we give an example of the abstract interpretation of a predicate which has a conjunction. The predicate tests if the parameters S and R which both naturally carry the structure ordered set actually both carry the structure ring. The predicate is: 2The source of the code is found in the file “EXPR2.spad” in OpenAxiom [Ope09] 5.4. ABSTRACT INTERPRETATION OF CATEGORIES 59 R has Ring and S has Ring The abstract store Φ for at the program point for the predicate has the value: Φ = { 〈S has Ring 7→ 1/2〉, 〈R has Ring 7→ 1〉, ... } The evaluation of the predicate in Φ is: Φ(R has Ring and S has Ring) = Φ(R has Ring) andK Φ(R has Ring) = 1 andK 1/2 = 1/2 The abstract interpretation of the predicate is shown below: JR has Ring and S has RingK = JR has RingK t JS has RingK =  〈R has Ring 7→ 1〉, 〈R has Group 7→ 1〉, · · ·  t  〈S has Ring 7→ 1〉, 〈S has Group 7→ 1〉, · · ·  =  〈R has Ring 7→ 1〉, 〈R has Group 7→ 1〉, 〈S has Ring 7→ 1〉, 〈S has Group 7→ 1〉, · · ·  Implementation of hascat in the Prototype The implementation of “hascat” is a function that takes three arguments: the syntactic representation of a domain D, the syntactic representation of an instantiated category C, and the current abstract store Φ of the category being abstractly interpreted. The function uses the Spad domain Table(Key, Entry) (a mapping from keys Key to entries Entry), where the function: key?:(Key,Table(Key,Entry)) →Boolean is analogous to the function “find” from the operational semantics defined in Section 5.2.4. We thus implement hascat as: hascat(D, C, Φ) == 2 key?(MakeHasCat(‘%,C), Application(D, Rename(Proj(Φ, D)), args(D), parms(C))) First, we call the function Application for the domain D, which returns a Spad Table containing facts which are expressed in terms of the symbol ‘% about D. Then we build the representation of a has-predicate with a call to MakeHasCat over ‘% and C, and look for that predicate in the table. The function hascat then relies heavily on the implementation of the function Application, described in the next section. Implementation of Application. The function Application takes the representation of an instantiated category ICat and an abstract store Phi representing the assumptions passed from the calling program point. Pseudo-code based on our prototype is shown below. Application(ICat, Phi) == 2 arity0? ICat ⇒ interpret(getDef(name(ICat)), Phi) instCatDef := getDef(name(ICat)) 4 for idx in 1..#args(ICat) repeat 60 CHAPTER 5. LOCAL SPECIALIZATION Phi’ := Application(args(ICat).idx, Phi) 6 Phi’ := Rename(Phi’, ‘%, parms(instCatDef).idx) Phi := join(Phi, Phi’) 8 Phi’’ := interpret(instCatDef, Phi) for idx in 1..args(ICat) repeat 10 Phi’’ := Rename(Phi’, args(ICat).idx, parms(instCatDef).idx) 12 Phi’’ If the instantiated category is a constant, a variable, or functor with arity = 0 it is just re-interpreted directly, with the interpret function. If arity > 0, then each argument args(ICat).idx of the instantiated category is recursively re-interpreted by a call to Application. The result is an abstract store with facts in terms of “%” about the argument; all facts about “%” are renamed to be facts about the argument parms(instCatDef).idx. All the abstract stores of the arguments are joined together into an abstract store called Phi’. The abstract store Phi’ is then used as assumptions for the re-interpretation of the instantiated category ICat. The syntactic representation for the category ICat is instCatDef which is acquired by a call to the global repository of syntactic representations getDef using the name of the category name(ICat). The syntactic representation is then re-interpreted, giving a new set of facts Phi’’. The facts in Phi’’ are in terms of the names of the formal parameters of the instantiated category, and are renamed to be in terms of the names of the actual arguments.